package main

import (
	"fmt"
)

//接口是一个协议-程序员-只要你能够1.写代码2．解决bug 其实就是一组方法的集合
type Programmer interface {
	//方法只是声明
	Coding() string
	Debug() string
}
type Designer interface {
	Design() string
}
type Manger interface {
	Programmer
	Designer
	Manage() string
}
type UIDesigner struct {
}

func (d UIDesigner) Design() string {
	fmt.Println("我会设计")
	return "我会设计"
}

type Pythoner struct {
	UIDesigner
	lib   []string
	kj    []string
	years int
}
type G struct {
}

func (p G) Coding() string {
	fmt.Println("go开发者")
	return "go开发者"
}
func (p G) Debug() string {
	fmt.Println("我会go的Debug")
	return "我会go的Debug"
}

func (p Pythoner) Coding() string {
	fmt.Println("python开发者")
	return "python开发者"
}
func (p Pythoner) Debug() string {
	fmt.Println("我会python的Debug")
	return "我会python的Debug"
}
func (p Pythoner) Manage() string {
	fmt.Println("python管理")
	return "python管理"
}
func (p Pythoner) Design() string {
	fmt.Println("python设计")
	return "python设计"
}

/*type AliPay struct {
}
type WeChat struct {
}
type Bank struct {
}

var b Bank
var a AliPay
var w WeChat

//多态什么类型的时候你申明的类型是一种兼容类型，但是实际赋值的时候是另一种类型
//接口的强制性
var x Tongyong

x= Bank{}
x = AliPay{}
x = WeChat{}*/
type MyError struct {
}

func (m MyError) Error() string {
	return "错误"
}
func main() {
	//var pro Programmer = Pythoner{}
	var pros []Programmer
	pros = append(pros, Pythoner{})
	pros = append(pros, G{})
	pros[0].Coding()
	p := Pythoner{}
	fmt.Printf("%T\n", p)
	var pro Programmer = Pythoner{}
	fmt.Printf("%T\n", pro)
	var pro2 Programmer = G{}
	fmt.Printf("%T", pro2)

	var m Manger = Pythoner{}
	m.Design()
	//	struct组合完成了接口
	//python语言本身设计上是采用了完全的基于鸭子类型–协议影响了python语法的 for len( )
	//struct组合完成了接口1．接口支持组合–继承2．结构体组合实现了所有的接口方法也没有问题
	//go语言本身也推荐鸭子类型error
	//var err error = MyError{}
	//var err error = errors.New("错误")
	s := "文件不存在"
	var err error = fmt.Errorf("错误：%s", s)
	fmt.Println(err)

}
